/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.javahispano.javacup.tacticas_aceptadas.Goteck;

import java.util.Iterator;
import java.util.Vector;
import org.javahispano.javacup.modelo.Constantes;
import org.javahispano.javacup.modelo.Posicion;
import org.javahispano.javacup.modelo.SituacionPartido;
import org.javahispano.javacup.tacticas_aceptadas.Goteck.Acciones.Tiro;

/**
 *
 * @author Administrador
 */
public class Estado_Jugada {

    
    static Balon balon;
    static int desconocido=0;
    static int La_tengo=1;
    static int Pasando=2;
    static int Tirando=3;
    static int Regateando=4;
    static int Saco_Medio=5;
    static int Saco_Banda=6;
    static int En_disputa=7;
    static int La_tiene=8;
    static int Esta_pasando=9;
    static int Esta_tirando=10;
    static int Saca_el_medio=11;
    static int Saca_el_banda=12;
    static int Esta_regateando=13;


    static int valorarPos(SituacionPartido sp,Posicion p){

        double distancia=p.getY();
        double ang=(90-Math.abs(p.angulo(Constantes.centroArcoSup)));
        double distRival=10000000;
        for(int i=0;i<11;i++){
            if(sp.rivales()[i].distancia(p)<distRival){distRival=sp.rivales()[i].distancia(p);}
        }

        int valor=(int) (100 + distancia - ang / 4);
        if(distRival>=15){valor=valor+700;}
        
return valor;
    }
    static int compararMejor1 (SituacionPartido sp,Posicion pos1,Posicion pos2){
        double val1=valorarPos(sp,pos1);
        double val2=valorarPos(sp,pos2);

        if(val2+20<val1){return 10;}
        else if(val2+25<val1){return 9;}
        else if(val2+10<val1){return 8;}
        else if(val2+5<val1){return 7;}
        else if(val2+2<val1){return 6;}
        else if(val2<val1){return 5;}
        else if(val2<val1+10){return 4;}
        else if(val2<val1+20){return 3;}
        else if(val2<val1+30){return 2;}
        else {return 1;}



    }

static void actualizarBalon(Balon pbalon){
    balon=pbalon;
}
    static public int valorarTirar(SituacionPartido sp){
        if(sp.iteracionesParaRematar().length>0){
double distancia=sp.balon().distancia(Constantes.centroArcoSup);

double angulo=Math.toDegrees(sp.balon().angulo(Constantes.centroArcoSup));


int mejorValor=-1000000;
int aux=0;
while(aux<sp.puedenRematar().length){
    double precision=sp.detalleMisJugadores()[sp.puedenRematar()[aux]].getPresicion();
    double fuerza=sp.detalleMisJugadores()[sp.puedenRematar()[aux]].getRemate();
    double errorPosible=25-20*precision;

    double angPorteria=sp.misJugadores()[sp.puedenRematar()[aux]].angulo(Constantes.posteIzqArcoSup)-
            sp.misJugadores()[sp.puedenRematar()[aux]].angulo(Constantes.posteDerArcoSup);
     double probPorteria=angPorteria/errorPosible;
    Acciones.Tiro tiro=Acciones.CalcMejorTiro(fuerza, distancia);
    int valor=-1;
    if((tiro.dist<3&probPorteria>0.9|distancia<25)){valor= 5;}
    else if (tiro.dist<5&probPorteria>0.7){valor= 4;}
    else if (tiro.dist<8){valor= 3;}
    else {valor=2;}
    if(valor>mejorValor){mejorValor=valor;}
    aux++;
}

//int porteroMal=(int) sp.rivales()[TacticaMonsters.PorteroRival].distancia(Constantes.centroArcoInf);
return    mejorValor; //+porteroMal;

        }
        else{return 0;}
    }
    
    static public int valorarPasar(SituacionPartido sp){
        if(sp.puedenRematar().length>0){
            
          
           
            

           int val=Integer.MIN_VALUE;
           
            int[] listaJ= sp.balon().indicesMasCercanos(sp.misJugadores(), sp.puedenRematar());
           int aux=0;
           int jugLibre=-1;
           int jugAdelantado=-1;
           double posicionAdelantadoLibre=Integer.MIN_VALUE;
           double posicionAdelantado=Integer.MIN_VALUE;
           Acciones.Tiro tiroPaseLibre;
           Acciones.Tiro tiroPaseAdelantado;
           boolean encontrado=false;
           double valor =-1000000;
           while(aux<listaJ.length){
               if(sp.balon().distancia(sp.misJugadores()[listaJ[aux]])<70&sp.misJugadores()[listaJ[aux]].getY()>sp.balon().getY()){
                   double fuerzaJug=sp.detalleMisJugadores()[sp.puedenRematar()[0]].getRemate();
               Acciones.Tiro t=Acciones.CalcMejorPase(fuerzaJug, sp.balon().distancia(sp.misJugadores()[listaJ[aux]]));
               Balon b=Acciones.balon.obtBalonSimTiro(fuerzaJug, t.fuerza, t.angVertical,sp.balon().angulo(sp.misJugadores()[listaJ[aux]]));
              double valorAct=valorarPaseSeguro(sp,listaJ[aux]);
              boolean paseMejor=false;
              if(valorAct>valor){
                  paseMejor=true;
                  valor=valorAct;
              }
              if (b.destinoBalon(sp).equals("mia")&paseMejor){
                 
                   //if(sp.misJugadores()[listaJ[aux]].getY()>posicionAdelantadoLibre){
                      
                       TacticaMonsters.paseTiro=t;
                   //posicionAdelantadoLibre= sp.misJugadores()[listaJ[aux]].getY();
                       valor=valorAct;
                   jugLibre=aux;}
               
              
              else{
                   double dist1=7;
             double dist2=14;
             for (int j=0;j<360;j=j+45){
                  if(j>180){

                 Posicion posNueva=new Posicion(sp.misJugadores()[listaJ[aux]].getX()+Math.cos(Math.toRadians(j))*dist1,
                        sp.misJugadores()[listaJ[aux]].getY()+Math.sin(Math.toRadians(j))*dist1 );
                  if(Math.abs(posNueva.getX())<Constantes.ANCHO_CAMPO_JUEGO/2&Math.abs(posNueva.getY())<Constantes.LARGO_CAMPO_JUEGO/2){
                      Tiro t2=Acciones.CalcMejorPase(sp.detalleMisJugadores()[sp.puedenRematar()[0]].getRemate(), sp.balon().distancia(posNueva));
           b=Acciones.balon.obtBalonSimTiro(fuerzaJug, t2.fuerza, t2.angVertical,sp.balon().angulo(posNueva));
           String destino= b.destinoBalon(sp);
        
           if (destino.equals("mia")&&paseMejor){//&sp.misJugadores()[listaJ[aux]].getY()>posicionAdelantadoLibre){
                
               TacticaMonsters.paseTiro=t2;
               posicionAdelantadoLibre= sp.misJugadores()[listaJ[aux]].getY();

        
                  }}
             if(j<=180){
                posNueva=new Posicion(sp.misJugadores()[listaJ[aux]].getX()+Math.cos(Math.toRadians(j))*dist2,
                        sp.misJugadores()[listaJ[aux]].getY()+Math.sin(Math.toRadians(j))*dist2 );
                  if(Math.abs(posNueva.getX())<Constantes.ANCHO_CAMPO_JUEGO/2&Math.abs(posNueva.getY())<Constantes.LARGO_CAMPO_JUEGO/2){
                      Tiro t2=Acciones.CalcMejorPase(sp.detalleMisJugadores()[sp.puedenRematar()[0]].getRemate(), sp.balon().distancia(posNueva));
           b=Acciones.balon.obtBalonSimTiro(fuerzaJug, t2.fuerza, t2.angVertical,sp.balon().angulo(posNueva));
            if (b.destinoBalon(sp).equals("mia")&&paseMejor){//sp.misJugadores()[listaJ[aux]].getY()>posicionAdelantadoLibre){
              
                TacticaMonsters.paseTiro=t2;
                posicionAdelantadoLibre= sp.misJugadores()[listaJ[aux]].getY();
       
         
        
            }

             }}}}
             ///////////////////////////////////////////
              }

               if(sp.misJugadores()[listaJ[aux]].getY()>posicionAdelantado){
                   posicionAdelantado= sp.misJugadores()[listaJ[aux]].getY();
               jugAdelantado=aux;}
               
               }
               aux++;
           }
         
           boolean mejorLibre=false;
           if(posicionAdelantadoLibre>=sp.balon().getY()){TacticaMonsters.JugPase=listaJ[jugLibre];
           mejorLibre=true;}
           else{
               if(jugAdelantado<0){jugAdelantado=10;}
               TacticaMonsters.JugPase=listaJ[jugAdelantado];
           TacticaMonsters.paseTiro=new Tiro(1,45,20000);}


           if(mejorLibre){
               if(sp.misJugadores()[TacticaMonsters.JugPase].getY() > sp.balon().getY()+20){
                   return 5;
               }
               else if(sp.misJugadores()[TacticaMonsters.JugPase].getY() > sp.balon().getY()){
                   return 4;
               }
               else if(sp.misJugadores()[TacticaMonsters.JugPase].getY() +20 > sp.balon().getY()){
                   return 3;
               }
               else return 0;

           }else if(sp.misJugadores()[TacticaMonsters.JugPase].getY() > sp.balon().getY()+20){return 4;}
           else if(sp.misJugadores()[TacticaMonsters.JugPase].getY() > sp.balon().getY()){return 3;}
           else {return 0;}
          
          
           


        }
        else return 0;
        
    }
    static public int valorarRegatear(SituacionPartido sp){
       
        if(sp.puedenRematar().length>0){

        if(sp.puedenRematar()[0]==0){return 0;}
       Posicion p=posicionLibrarse(sp,sp.puedenRematar()[0]);
       if(p==null){return 0;}
       else {
          
          double distAct=sp.balon().distancia(Constantes.centroArcoSup);
          double distSig=p.distancia(Constantes.centroArcoSup);
          if(distSig<distAct){return 5;}
          else{return 4;}

          }

       }
       
    else return 0;



        
       
    }
    static public int valorarQuedarseQuieto(SituacionPartido sp){
        return 0;
    }
     static public Posicion posicionLibrarse(SituacionPartido sp,int jug){
         

         double limMuyCerca = 8;
         double cerca = 25;
         boolean imposible = false;

        


         double velocidad = sp.detalleMisJugadores()[jug].getVelocidad();
        
         double dist = (0.30+0.30*velocidad)*11;
         

        

         double valorAct=100-sp.balon().distancia(Constantes.centroArcoSup)-(90-Math.abs(Math.toDegrees(sp.balon().angulo(Constantes.centroArcoSup))));
         boolean enemRematan=sp.puedenRematarRival().length>0;
         int numEne=0;
         if(enemRematan){numEne=sp.puedenRematarRival().length;
         valorAct=valorAct-20*numEne;}
         else{valorAct=valorAct+1000;}

         double mejorVal=-10000000;
         
         Posicion mejorPos = null;

         for(int i=0;i<360;i++){
             Posicion nuevaPos=new Posicion(sp.balon().getX()+Math.cos(Math.toRadians(i))*dist,sp.balon().getY()+Math.sin(Math.toRadians(i))*dist);
             if(Math.abs(nuevaPos.getX())<Constantes.ANCHO_CAMPO_JUEGO/2&Math.abs(nuevaPos.getY())<Constantes.LARGO_CAMPO_JUEGO/2){
                 double valAct=100-nuevaPos.distancia(Constantes.centroArcoSup)-(90-Math.abs(Math.toDegrees(nuevaPos.angulo(Constantes.centroArcoSup))));
                 int enemigosBalon=0;
                 for(int j=0;j<11;j++){
                     double distControl=Constantes.DISTANCIA_CONTROL_BALON;
                     if(sp.detalleJugadoresRivales()[j].esPortero()){distControl=Constantes.DISTANCIA_CONTROL_BALON_PORTERO;}
                     if(sp.rivales()[j].distancia(nuevaPos)<=10*sp.detalleJugadoresRivales()[j].getVelocidad()+distControl){enemigosBalon++;}
                 }
                 if(enemigosBalon==0){valAct=valAct+1000;}
                 else{valAct=valAct-20*enemigosBalon;}

                 if(valAct>mejorVal){
                 mejorVal=valAct;
                 mejorPos=nuevaPos;

                 }

                 }
             }
             if(mejorVal>250){return mejorPos;}
             else return null;
         
        
         






        
    }


    static String SituacionJugador(Posicion pJugador,SituacionPartido sp){
        //hay k mejorarrr para ver si puede escapar el jugaorrr
int aux=0;
double distanciaMenor=Integer.MAX_VALUE;
int nRivalesCerca=0;
while(aux<sp.rivales().length){
    double dist=sp.rivales()[aux].distancia(pJugador);
    if(dist<distanciaMenor){distanciaMenor=dist;}
    if(dist<15){nRivalesCerca++;}

    aux++;
}
        if(distanciaMenor>22){return "solo";}
else if(distanciaMenor>12){return "me_libro";}
else {return "mal";}
        
    }
    static double valorarPaseSeguro(SituacionPartido sp,int jug){
        double distBalonJugador=sp.balon().distancia(sp.misJugadores()[jug]);
         double distRival=10000000;
         double velRival=0;
        for(int i=0;i<11;i++){
            if(sp.rivales()[i].distancia(sp.misJugadores()[jug])<distRival){
                distRival=sp.rivales()[i].distancia(sp.misJugadores()[jug]);
            velRival=sp.detalleJugadoresRivales()[i].getVelocidad();}
        }
        double velBalonHorizontal=1;
        double itBalonJug=(int) (distBalonJugador / velBalonHorizontal);
        double itRivalJug=(int) (distRival / velRival);
        return itBalonJug/itRivalJug;


    }



}
